﻿using Dao;
using Interface.BO;
using Interface.DAO;
using JMI_Nucleo.Classe;
using JMI_Nucleo.JMIProvider;
using OR;
using System;
using System.Collections.Generic;
using System.Data.Common;

namespace BO
{
    public class Funcionario : IFuncionario
    {
        private string msgErro = String.Empty;

        private IFuncionarioDao<mFuncionario> dao;        

        public string MsgErro { get { return msgErro; } }

        public Funcionario()
        {
            dao = DaoFactory<FuncionarioDao>.Create();
        }

        private bool Valida(mFuncionario _mFuncionario)
        {
            bool retorno = true;
            JMIUtil util = new JMIUtil();

            if (_mFuncionario.Pessoa.Nome == String.Empty)
            {
                msgErro = "Nome, Campo Obrigatório.";
                retorno = false;
            }
            if (!String.IsNullOrEmpty(_mFuncionario.Pessoa.CPF))
            {
                if (!util.CpfValido(_mFuncionario.Pessoa.CPF))
                {
                    msgErro = "CPF inválido.";
                    retorno = false;
                }
            }
            if (!String.IsNullOrEmpty(_mFuncionario.Contato.Email1))
            {
                if (!util.IsValidaEmail(_mFuncionario.Contato.Email1))
                {
                    msgErro = "E-mail inválido.";
                    retorno = false;
                }
            }
            
            return retorno;
        }

        public bool Salvar(mFuncionario _mFuncionario, char Acao)
        {
            bool retorno = false;
            DbTransaction trans;

            try
            {
                EngineBD.Conectar();
                trans = EngineBD.IniciaTransacao();

                if (Valida(_mFuncionario))
                {
                    if (Acao == 'I')
                        retorno = dao.Inserir(_mFuncionario);
                    else if (Acao == 'A')
                        retorno = dao.Alterar(_mFuncionario);
                    retorno = EngineBD.FinalizaTransacao(trans, retorno);
                }
            }
            catch (Exception exc)
            {
                retorno = false;
                msgErro = "Falha na gravação dos dados, " + exc.Message;
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return retorno;
        }
        public bool Excluir(mFuncionario _mFuncionario)
        {
            bool retorno = false;
            DbTransaction trans;
            try
            {
                EngineBD.Conectar();
                trans = EngineBD.IniciaTransacao();
                retorno = dao.Excluir(_mFuncionario);
                EngineBD.FinalizaTransacao(trans, retorno);
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return retorno;
        }

        public mFuncionario GetFuncionario(int Codigo, short Empresa)
        {
            mFuncionario _mFuncionario;

            try
            {
                EngineBD.Conectar();
                _mFuncionario = dao.GetFuncionario(Codigo, Empresa);
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return _mFuncionario;
        }

        public short GetCodigo(string Nome)
        {
            short codigo = 0;

            try
            {
                EngineBD.Conectar();
                codigo = dao.GetCodigo(Nome);
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return codigo;
        }

        public string GetNome(short Codigo)
        {
            string nome = String.Empty;

            try
            {
                EngineBD.Conectar();
                nome = dao.GetNome(Codigo);
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return nome;
        }

        public List<string> GetListaNome(short Empresa)
        {
            List<string> lstNome = null;

            try
            {
                EngineBD.Conectar();
                lstNome = dao.GetListaNome(Empresa);
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return lstNome;
        }

        public List<mFuncionario> GetListaPorFiltro(mFuncionario _mFuncionario)
        {
            List<mFuncionario> lstFuncionario;

            try
            {
                EngineBD.Conectar();
                lstFuncionario = dao.GetListaPorFiltro(_mFuncionario);
            }
            finally
            {
                EngineBD.Desconectar();
            }
            return lstFuncionario;
        }
    }
}
